home *** CD-ROM | disk | FTP | other *** search
/ Aminet 33 / Aminet 33 - October 1999.iso / Aminet / util / misc / VMM_src.lha / VMM / MUI / config.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-12-16  |  16.1 KB  |  517 lines
  1. #include "defs.h"
  2.  
  3. #define isspace(c) (((c)==' ') || ((c) == '\t') || ((c) == '\n'))
  4.  
  5. static char rcsid [] = "$Id: config.c,v 3.6 95/12/16 19:02:56 Martin_Apel Rel $";
  6.  
  7. #define VERSION 3
  8. #define REVISION 3
  9.  
  10. #define AT_LEAST_3_1 ((CurrentConfig.Version > 3) || \
  11.                      (CurrentConfig.Version == 3 && CurrentConfig.Revision >= 1))
  12. #define AT_LEAST_3_3 ((CurrentConfig.Version > 3) || \
  13.                      (CurrentConfig.Version == 3 && CurrentConfig.Revision >= 3))
  14.  
  15. /************************************************************************/
  16.  
  17. static void AllowVM (BOOL Allowed)
  18.  
  19. {
  20. struct MsgPort *VMPort;
  21. struct VMMsg *AbleMsg;
  22. LONG AckSignal;
  23.  
  24. if ((VMPort = FindPort (VMPORTNAME)) == NULL)
  25.   return;
  26.  
  27. if ((AbleMsg = AllocMem (sizeof (struct VMMsg), MEMF_PUBLIC)) == NULL)
  28.   return;
  29.  
  30. if ((AckSignal = AllocSignal (-1L)) == -1)
  31.   {
  32.   FreeMem (AbleMsg, sizeof (struct VMMsg));
  33.   return;
  34.   }
  35.  
  36. AbleMsg->VMSender = FindTask (NULL);
  37. AbleMsg->ReplySignal = AckSignal;
  38. AbleMsg->VMCommand = Allowed ? VMCMD_EnableVM : VMCMD_DisableVM;
  39.  
  40. PutMsg (VMPort, (struct Message*) AbleMsg);
  41. Wait (1L << AckSignal);
  42.  
  43. FreeMem (AbleMsg, sizeof (struct VMMsg));
  44. FreeSignal (AckSignal);
  45. }
  46.  
  47. /************************************************************************/
  48.  
  49. void ReadConfigFromVMM (void)
  50.  
  51. {
  52. /* Tries to contact VMM to get the current configuration of VMM.
  53.  * The task list is not requested, it is taken from the config file.
  54.  */
  55.  
  56. struct MsgPort *VMPort;
  57. struct VMMsg *CfgQuestion;
  58. ULONG CfgSignal;
  59. struct VMMConfig *CurrentConfig;
  60. struct TaskEntry *DefaultEntry;
  61. ULONG MemType;
  62.  
  63. if ((CurrentConfig = AllocMem (sizeof (struct VMMConfig), MEMF_PUBLIC)) != NULL)
  64.   {
  65.   if ((CfgQuestion = AllocMem (sizeof (struct VMMsg), MEMF_PUBLIC)) != NULL)
  66.     {
  67.     if ((CfgSignal = AllocSignal (-1L)) != -1)
  68.       {
  69.       CfgQuestion->VMCommand = VMCMD_AskConfig;
  70.       CfgQuestion->VMSender  = FindTask (NULL);
  71.       CfgQuestion->ReplySignal = CfgSignal;
  72.       CfgQuestion->Config = CurrentConfig;
  73.  
  74.       Forbid ();
  75.       if ((VMPort = FindPort (VMPORTNAME)) != NULL)
  76.         {
  77.         PutMsg (VMPort, (struct Message*)CfgQuestion);  
  78.         Permit ();
  79.         Wait (1L << CfgSignal);
  80.  
  81.         DoMethod (LV_TaskList, MUIM_List_GetEntry, 0L, &DefaultEntry);
  82.         DefaultEntry->te_teif.MinPublic = CurrentConfig->DefaultMinPublic;
  83.         DefaultEntry->te_teif.MinNonPublic = CurrentConfig->DefaultMinNonPublic;
  84.         DefaultEntry->te_teif.DataPaging = CurrentConfig->DefaultDataPaging;
  85.         DefaultEntry->te_teif.CodePaging = CurrentConfig->DefaultCodePaging;
  86.         DefaultEntry->te_teif.IsDefault = TRUE;
  87.  
  88.         DoMethod (LV_TaskList, MUIM_List_Redraw, 0L);
  89.  
  90.         if (CurrentConfig->MinMem == CurrentConfig->MaxMem)
  91.           MemType = MT_FIXED;
  92.         else if (CurrentConfig->MaxMem == DYN_MAX)
  93.           {
  94.           MemType = MT_DYNAMIC;
  95.           CurrentConfig->MinMem = CurrentConfig->MaxMem = 100 * 1024L;
  96.           }
  97.         else
  98.           MemType = MT_RESTRICTED;
  99.  
  100.         set (CY_Policy, MUIA_Cycle_Active, MemType);
  101.  
  102.         set (CY_MemFlags, MUIA_Cycle_Active, CurrentConfig->MemFlags >> 1);
  103.         set (SL_MinMem, MUIA_Slider_Max, MaxAvailMem (CurrentConfig->MemFlags) / (100 * 1024));
  104.         set (SL_MaxMem, MUIA_Slider_Max, MaxAvailMem (CurrentConfig->MemFlags) / (100 * 1024));
  105.         set (SL_MinMem, MUIA_Slider_Level, CurrentConfig->MinMem / (100 * 1024));
  106.         set (SL_MaxMem, MUIA_Slider_Level, CurrentConfig->MaxMem / (100 * 1024));
  107.  
  108.         set (CM_StatEnabled, MUIA_Selected, CurrentConfig->StatEnabled);
  109.         set (CM_Zoomed, MUIA_Selected, CurrentConfig->StatZoomed);
  110.         set (ST_ZLeft, MUIA_String_Integer, CurrentConfig->ZLeftEdge);
  111.         set (ST_ZTop, MUIA_String_Integer, CurrentConfig->ZTopEdge);
  112.         set (ST_UnZLeft, MUIA_String_Integer, CurrentConfig->UnZLeftEdge);
  113.         set (ST_UnZTop, MUIA_String_Integer, CurrentConfig->UnZTopEdge);
  114.  
  115.         if (CurrentConfig->PageDev == PD_PART)
  116.           {
  117.           char *tmp = CurrentConfig->PartOrFileName;
  118.         
  119.           *(tmp + strlen (tmp) - 1) = 0;
  120.           set (ST_PartName, MUIA_String_Contents, CurrentConfig->PartOrFileName);
  121.           set (ST_FileName, MUIA_String_Contents, NULL);
  122.           set (SL_FileSize, MUIA_Slider_Level, 1);
  123.           }
  124.         else
  125.           {
  126.           set (ST_FileName, MUIA_String_Contents, CurrentConfig->PartOrFileName);
  127.           set (SL_FileSize, MUIA_Slider_Level, CurrentConfig->FileSize);
  128.           set (ST_PartName, MUIA_String_Contents, NULL);
  129.           }
  130.  
  131.         set (CY_Device, MUIA_Cycle_Active, CurrentConfig->PageDev);
  132.         set (SL_Prio, MUIA_Slider_Level, CurrentConfig->VMPriority);
  133.         set (CM_CacheZ2RAM, MUIA_Selected, CurrentConfig->CacheZ2RAM);
  134.         set (CM_WBPatch, MUIA_Selected, CurrentConfig->PatchWB);
  135.         set (ST_MinVMAlloc, MUIA_String_Integer, CurrentConfig->MinVMAlloc);
  136.         set (ST_EnableHotkey, MUIA_String_Contents, CurrentConfig->EnableHotkey);
  137.         set (ST_DisableHotkey, MUIA_String_Contents, CurrentConfig->DisableHotkey);
  138.         set (SL_Buffer, MUIA_Slider_Level, CurrentConfig->WriteBuffer / (10 * 1024));
  139.         set (CM_MemTracking, MUIA_Selected, CurrentConfig->MemTracking);
  140.         }
  141.       else
  142.         Permit ();
  143.  
  144.       FreeSignal (CfgSignal);
  145.       }
  146.     FreeMem (CfgQuestion, sizeof (struct VMMsg));
  147.     }
  148.   FreeMem (CurrentConfig, sizeof (struct VMMConfig));
  149.   }
  150. }
  151.  
  152. /************************************************************************/
  153.  
  154. static BOOL ReadOldTaskEntry (BPTR cfg_file, char *filename)
  155.  
  156. {
  157. struct OldTaskEntryInFile old_te;
  158. struct TaskEntry te;
  159.  
  160. if (Read (cfg_file, &old_te, sizeof (struct OldTaskEntryInFile)) != 
  161.     sizeof (struct OldTaskEntryInFile))
  162.   {
  163.   MUI_Request (Application, 0L, 0L, NULL, "*_OK", GetVMMString (msgCorruptCfgFile), filename);
  164.   return (FALSE);
  165.   }
  166.  
  167. te.te_TaskName = old_te.TaskName;
  168. te.te_teif.MinPublic = old_te.MinPublic;
  169. te.te_teif.MinNonPublic = old_te.MinNonPublic;
  170. te.te_teif.DataPaging = old_te.DataPaging;
  171. te.te_teif.CodePaging = old_te.CodePaging;
  172. te.te_teif.IsDefault = old_te.IsDefault;
  173. te.te_teif.NameLen = strlen (old_te.TaskName) + 1;
  174.  
  175. DoMethod (LV_TaskList, MUIM_List_InsertSingle, &te, MUIV_List_Insert_Bottom);
  176. return (TRUE);
  177. }
  178.  
  179. /************************************************************************/
  180.  
  181. static BOOL ReadNewTaskEntry (BPTR cfg_file, char *filename)
  182.  
  183. {
  184. struct TaskEntry te;
  185.  
  186. if (Read (cfg_file, &(te.te_teif), sizeof (struct TaskEntryInFile)) != 
  187.     sizeof (struct TaskEntryInFile))
  188.   {
  189.   MUI_Request (Application, 0L, 0L, NULL, "*_OK", GetVMMString (msgCorruptCfgFile), filename);
  190.   return (FALSE);
  191.   }
  192.  
  193. if ((te.te_TaskName = AllocMem ((ULONG)te.te_teif.NameLen, MEMF_PUBLIC)) == NULL)
  194.   {
  195.   MUI_Request (Application, 0L, 0L, NULL, "*_OK", GetVMMString (msgOutOfMem));
  196.   return (FALSE);
  197.   }
  198.  
  199. if (Read (cfg_file, te.te_TaskName, (ULONG)te.te_teif.NameLen) != te.te_teif.NameLen)
  200.   {
  201.   MUI_Request (Application, 0L, 0L, NULL, "*_OK", GetVMMString (msgCorruptCfgFile), filename);
  202.   FreeMem (te.te_TaskName, (ULONG)te.te_teif.NameLen);
  203.   return (FALSE);
  204.   }
  205.  
  206. DoMethod (LV_TaskList, MUIM_List_InsertSingle, &te, MUIV_List_Insert_Bottom);
  207.  
  208. FreeMem (te.te_TaskName, (ULONG)te.te_teif.NameLen);
  209. return (TRUE);
  210. }
  211.  
  212. /************************************************************************/
  213.  
  214. BOOL ReadConfigFileMUI (char *filename)
  215.  
  216. {
  217. /* This function reads the config file and sets the MUI gadgets 
  218.  * accordingly.
  219.  */
  220.  
  221. BPTR cfg_file;
  222. struct TaskEntry te;
  223. static struct VMMConfig CurrentConfig;
  224. ULONG MemType;
  225. int i;
  226. BOOL success;
  227.  
  228. AllowVM (FALSE);         /* So RAM will not allocate any VM */
  229.  
  230. if ((cfg_file = Open (filename, MODE_OLDFILE)) == NULL)
  231.   {
  232.   MUI_Request (Application, 0L, 0L, NULL, "*_OK", GetVMMString (msgNoCfgFile), filename);
  233.   AllowVM (TRUE);
  234.   return (FALSE);
  235.   }
  236.  
  237. if ((Read (cfg_file, &CurrentConfig, sizeof (struct VMMConfig)) != 
  238.      sizeof (struct VMMConfig)) || (CurrentConfig.CfgMagic != CFG_MAGIC))
  239.   {
  240.   MUI_Request (Application, 0L, 0L, NULL, "*_OK", GetVMMString (msgCorruptCfgFile), filename);
  241.   Close (cfg_file);
  242.   AllowVM (TRUE);
  243.   return (FALSE);
  244.   }
  245.  
  246. set (LV_TaskList, MUIA_List_Quiet, TRUE);
  247. DoMethod (LV_TaskList, MUIM_List_Clear);
  248.  
  249. te.te_TaskName = GetVMMString (msgDefault);
  250. te.te_teif.MinPublic = CurrentConfig.DefaultMinPublic;
  251. te.te_teif.MinNonPublic = CurrentConfig.DefaultMinNonPublic;
  252. te.te_teif.DataPaging = CurrentConfig.DefaultDataPaging;
  253. te.te_teif.CodePaging = CurrentConfig.DefaultCodePaging;
  254. te.te_teif.IsDefault = TRUE;
  255. te.te_teif.NameLen = strlen (te.te_TaskName) + 1;
  256.  
  257. DoMethod (LV_TaskList, MUIM_List_InsertSingle, &te, 0);
  258.  
  259. if (CurrentConfig.MinMem == CurrentConfig.MaxMem)
  260.   MemType = MT_FIXED;
  261. else if (CurrentConfig.MaxMem == DYN_MAX)
  262.   {
  263.   MemType = MT_DYNAMIC;
  264.   CurrentConfig.MinMem = CurrentConfig.MaxMem = 100 * 1024L;
  265.   }
  266. else
  267.   MemType = MT_RESTRICTED;
  268.  
  269. set (CY_Policy, MUIA_Cycle_Active, MemType);
  270. set (CY_MemFlags, MUIA_Cycle_Active, CurrentConfig.MemFlags >> 1);
  271. set (SL_MinMem, MUIA_Slider_Max, MaxAvailMem (CurrentConfig.MemFlags) / (100 * 1024));
  272. set (SL_MaxMem, MUIA_Slider_Max, MaxAvailMem (CurrentConfig.MemFlags) / (100 * 1024));
  273. set (SL_MinMem, MUIA_Slider_Level, CurrentConfig.MinMem / (100 * 1024));
  274. set (SL_MaxMem, MUIA_Slider_Level, CurrentConfig.MaxMem / (100 * 1024));
  275.  
  276. set (CM_StatEnabled, MUIA_Selected, CurrentConfig.StatEnabled);
  277. set (CM_Zoomed, MUIA_Selected, CurrentConfig.StatZoomed);
  278. set (ST_ZLeft, MUIA_String_Integer, CurrentConfig.ZLeftEdge);
  279. set (ST_ZTop, MUIA_String_Integer, CurrentConfig.ZTopEdge);
  280. set (ST_UnZLeft, MUIA_String_Integer, CurrentConfig.UnZLeftEdge);
  281. set (ST_UnZTop, MUIA_String_Integer, CurrentConfig.UnZTopEdge);
  282.  
  283. if (CurrentConfig.PageDev == PD_PART)
  284.   {
  285.   char *tmp = CurrentConfig.PartOrFileName;
  286.  
  287.   *(tmp + strlen (tmp) - 1) = 0;
  288.   set (ST_PartName, MUIA_String_Contents, CurrentConfig.PartOrFileName);
  289.   set (ST_FileName, MUIA_String_Contents, NULL);
  290.   set (SL_FileSize, MUIA_Slider_Level, 1);
  291.   }
  292. else
  293.   {
  294.   set (ST_FileName, MUIA_String_Contents, CurrentConfig.PartOrFileName);
  295.   set (SL_FileSize, MUIA_Slider_Level, CurrentConfig.FileSize);
  296.   set (ST_PartName, MUIA_String_Contents, NULL);
  297.   }
  298.  
  299. set (CY_Device, MUIA_Cycle_Active, CurrentConfig.PageDev);
  300. set (SL_Prio, MUIA_Slider_Level, CurrentConfig.VMPriority);
  301. set (CM_CacheZ2RAM, MUIA_Selected, CurrentConfig.CacheZ2RAM);
  302. set (CM_WBPatch, MUIA_Selected, CurrentConfig.PatchWB);
  303. set (ST_MinVMAlloc, MUIA_String_Integer, CurrentConfig.MinVMAlloc);
  304. set (ST_EnableHotkey, MUIA_String_Contents, CurrentConfig.EnableHotkey);
  305. set (ST_DisableHotkey, MUIA_String_Contents, CurrentConfig.DisableHotkey);
  306. set (SL_Buffer, MUIA_Slider_Level, CurrentConfig.WriteBuffer / (10 * 1024));
  307. set (CM_MemTracking, MUIA_Selected, CurrentConfig.MemTracking);
  308. if (AT_LEAST_3_1)
  309.   set (CM_FastROM, MUIA_Selected, CurrentConfig.FastROM);
  310.  
  311. for (i = 0; i < CurrentConfig.NumTaskEntries; i++)
  312.   {
  313.   if (AT_LEAST_3_3)
  314.     {
  315.     if (!(success = ReadNewTaskEntry (cfg_file, filename)))
  316.       break;
  317.     }
  318.   else
  319.     {
  320.     if (!(success = ReadOldTaskEntry (cfg_file, filename)))
  321.       break;
  322.     }
  323.   }
  324.  
  325. set (LV_TaskList, MUIA_List_Active, 0);
  326. set (LV_TaskList, MUIA_List_Quiet, FALSE);
  327.  
  328. Close (cfg_file);
  329. AllowVM (TRUE);
  330. return (success);
  331. }
  332.  
  333. /***********************************************************************/
  334.  
  335. void ReadHotkeysFromConfig (char *filename)
  336.  
  337. {
  338. /* This function reads only the hotkey lines from the config file.
  339.  * This is needed in case of a direct start without opening the 
  340.  * user interface.
  341.  */
  342.  
  343. BPTR cfg_file;
  344. struct VMMConfig CurrentConfig;
  345.  
  346. strcpy (EnableVMHotkey, DEFAULT_ENABLE_KEY);
  347. strcpy (DisableVMHotkey, DEFAULT_DISABLE_KEY);
  348.  
  349. AllowVM (FALSE);         /* So RAM will not allocate any VM */
  350.  
  351. if ((cfg_file = Open (filename, MODE_OLDFILE)) != NULL)
  352.   {
  353.   if ((Read (cfg_file, &CurrentConfig, sizeof (struct VMMConfig)) ==
  354.        sizeof (struct VMMConfig)) && (CurrentConfig.CfgMagic == CFG_MAGIC))
  355.     {
  356.     strcpy (EnableVMHotkey, CurrentConfig.EnableHotkey);
  357.     strcpy (DisableVMHotkey, CurrentConfig.DisableHotkey);
  358.     }
  359.  
  360.   }
  361.  
  362. Close (cfg_file);
  363. AllowVM (TRUE);
  364. }
  365.  
  366. /***********************************************************************/
  367.  
  368. BOOL WriteConfigFile (char *filename)
  369.  
  370. {
  371. BPTR cfg_file;
  372. struct TaskEntry *cur_task;
  373. struct VMMConfig CurrentConfig;
  374. ULONG Policy;
  375. char *tmp;
  376. int i;
  377. ULONG val;
  378.  
  379. AllowVM (FALSE);
  380.  
  381. if ((cfg_file = Open (filename, MODE_NEWFILE)) == NULL)
  382.   {
  383.   AllowVM (TRUE);
  384.   return (FALSE);
  385.   }
  386.  
  387. CurrentConfig.CfgMagic = CFG_MAGIC;
  388. CurrentConfig.Version = VERSION;
  389. CurrentConfig.Revision = REVISION;
  390. get (LV_TaskList, MUIA_List_Entries, &(CurrentConfig.NumTaskEntries));
  391.  
  392. /* Default is stored separately */
  393. CurrentConfig.NumTaskEntries -= 1; 
  394.  
  395. /* Task params are read when needed */
  396.  
  397. /* Memory page */
  398. get (CY_Policy, MUIA_Cycle_Active, &Policy);
  399. get (SL_MinMem, MUIA_Slider_Level, &(CurrentConfig.MinMem));
  400. CurrentConfig.MinMem *= 100 * 1024;
  401. get (SL_MaxMem, MUIA_Slider_Level, &(CurrentConfig.MaxMem));
  402. CurrentConfig.MaxMem *= 100 * 1024;
  403.  
  404. switch (Policy)
  405.   {
  406.   case MT_FIXED: CurrentConfig.MaxMem = CurrentConfig.MinMem;
  407.                  break;
  408.   case MT_DYNAMIC: CurrentConfig.MinMem = DYN_MIN;
  409.                    CurrentConfig.MaxMem = DYN_MAX;
  410.                    break;
  411.   }
  412.  
  413. get (CY_MemFlags, MUIA_Cycle_Active, &(CurrentConfig.MemFlags));
  414. CurrentConfig.MemFlags = (CurrentConfig.MemFlags << 1) | MEMF_PUBLIC;
  415. get (SL_Buffer, MUIA_Slider_Level, &(CurrentConfig.WriteBuffer));
  416. CurrentConfig.WriteBuffer *= 10 * 1024;
  417. get (SL_Prio, MUIA_Slider_Level, &(CurrentConfig.VMPriority));
  418.  
  419. get (CY_Device, MUIA_Cycle_Active, &val);
  420. CurrentConfig.PageDev = (UWORD)val;
  421.  
  422. if (CurrentConfig.PageDev == PD_PART)
  423.   {
  424.   get (ST_PartName, MUIA_String_Contents, &tmp);
  425.   strcpy (CurrentConfig.PartOrFileName, tmp);
  426.   strcat (CurrentConfig.PartOrFileName, ":");
  427.   CurrentConfig.FileSize = 1;
  428.   }
  429. else
  430.   {
  431.   get (ST_FileName, MUIA_String_Contents, &tmp);
  432.   strcpy (CurrentConfig.PartOrFileName, tmp);
  433.   get (SL_FileSize, MUIA_Slider_Level, &(CurrentConfig.FileSize));
  434.   }
  435.  
  436. /* Statistics */
  437. get (CM_StatEnabled, MUIA_Selected, &val);
  438. CurrentConfig.StatEnabled = (BOOL) val;
  439. get (CM_Zoomed, MUIA_Selected, &val);
  440. CurrentConfig.StatZoomed = (BOOL) val;
  441. get (ST_ZLeft,   MUIA_String_Integer, &(CurrentConfig.ZLeftEdge));
  442. get (ST_ZTop,    MUIA_String_Integer, &(CurrentConfig.ZTopEdge));
  443. get (ST_UnZLeft, MUIA_String_Integer, &(CurrentConfig.UnZLeftEdge));
  444. get (ST_UnZTop,  MUIA_String_Integer, &(CurrentConfig.UnZTopEdge));
  445.  
  446. /* Misc */
  447. get (CM_CacheZ2RAM, MUIA_Selected, &val);
  448. CurrentConfig.CacheZ2RAM = (BOOL) val;
  449. get (CM_WBPatch,    MUIA_Selected, &val);
  450. CurrentConfig.PatchWB = (BOOL) val;
  451. get (CM_MemTracking,MUIA_Selected, &val);
  452. CurrentConfig.MemTracking = (BOOL) val;
  453. get (CM_FastROM,MUIA_Selected, &val);
  454. CurrentConfig.FastROM = (BOOL) val;
  455.  
  456. get (ST_MinVMAlloc, MUIA_String_Integer, &(CurrentConfig.MinVMAlloc));
  457. get (ST_EnableHotkey, MUIA_String_Contents, &tmp);
  458. strcpy (CurrentConfig.EnableHotkey, tmp);
  459. get (ST_DisableHotkey, MUIA_String_Contents, &tmp);
  460. strcpy (CurrentConfig.DisableHotkey, tmp);
  461.  
  462. DoMethod (LV_TaskList, MUIM_List_GetEntry, 0, &cur_task);
  463.  
  464. switch (cur_task->te_teif.DataPaging)
  465.   {
  466.   case DP_TRUE:
  467.        CurrentConfig.DefaultMinPublic = USE_NEVER;
  468.        CurrentConfig.DefaultMinNonPublic = USE_ALWAYS;
  469.        break;
  470.   case DP_FALSE:
  471.        CurrentConfig.DefaultMinPublic = USE_NEVER;
  472.        CurrentConfig.DefaultMinNonPublic = USE_NEVER;
  473.        break;
  474.   case DP_ADVANCED:
  475.        CurrentConfig.DefaultMinPublic = cur_task->te_teif.MinPublic;
  476.        CurrentConfig.DefaultMinNonPublic = cur_task->te_teif.MinNonPublic;
  477.        break;
  478.   }
  479.  
  480. CurrentConfig.DefaultCodePaging = cur_task->te_teif.CodePaging;
  481. CurrentConfig.DefaultDataPaging = cur_task->te_teif.DataPaging;
  482.  
  483. Write (cfg_file, &CurrentConfig, sizeof (struct VMMConfig));
  484.  
  485. /* First task is default */
  486. i = 1;
  487. DoMethod (LV_TaskList, MUIM_List_GetEntry, 1, &cur_task);
  488.  
  489. while (cur_task != NULL)
  490.   {
  491.   i++;
  492.  
  493.   switch (cur_task->te_teif.DataPaging)
  494.     {
  495.     case DP_TRUE:
  496.          cur_task->te_teif.MinPublic = USE_NEVER;
  497.          cur_task->te_teif.MinNonPublic = USE_ALWAYS;
  498.          break;
  499.     case DP_FALSE:
  500.          cur_task->te_teif.MinPublic = USE_NEVER;
  501.          cur_task->te_teif.MinNonPublic = USE_NEVER;
  502.          break;
  503.     case DP_ADVANCED:
  504.          break;
  505.     }
  506.  
  507.   Write (cfg_file, &(cur_task->te_teif), sizeof (struct TaskEntryInFile));
  508.   Write (cfg_file, cur_task->te_TaskName, (LONG)cur_task->te_teif.NameLen);
  509.            
  510.   DoMethod (LV_TaskList, MUIM_List_GetEntry, i, &cur_task);
  511.   }
  512.  
  513. Close (cfg_file);
  514. AllowVM (TRUE);
  515. return (TRUE);
  516. }
  517.